On October 2, 2024, the Python community is set to release CPython v3.13.0, which introduces significant changes that could transform Python's performance. The two major updates are the introduction of a "free-threaded" version of CPython, allowing the Global Interpreter Lock (GIL) to be disabled, and the addition of an experimental Just-in-Time (JIT) compiler. The GIL has been a fundamental aspect of Python since its inception, designed to simplify memory management and make garbage collection more efficient. However, it restricts Python's ability to fully utilize multi-core processors, which has become increasingly important as hardware evolves. The GIL allows only one thread to execute Python bytecode at a time, which can lead to performance bottlenecks in CPU-bound applications. While Python can still leverage multiple cores through multiprocessing, this approach comes with its own complexities and overhead. The push to remove the GIL has gained momentum due to the growing prevalence of multi-core processors and the diminishing returns of single-core performance improvements. A proof of concept by Sam Gross in 2021 demonstrated the feasibility of a no-GIL implementation, leading to the proposal of PEP 703, which aims to make the GIL optional. This proposal has been accepted and will be rolled out in phases, with the first phase introducing free-threading as an experimental option. Benchmarks comparing Python 3.12 and 3.13 show that while enabling free-threading results in a performance degradation of about 20% for single-threaded tasks, it significantly enhances multi-threaded performance. The benchmarks also indicate that multi-threading with the GIL disabled performs comparably to multiprocessing, highlighting the potential benefits of the new free-threading mode. In addition to the GIL changes, Python 3.13 introduces an experimental JIT compiler, which compiles bytecode into machine code at runtime. This "copy-and-patch" JIT approach allows for optimizations based on how frequently certain code paths are executed, potentially leading to performance improvements over time. While the JIT is still in its early stages and may not yield immediate benefits, it sets the groundwork for future enhancements in Python's performance. To experiment with the new features, users can install the release candidate of Python 3.13 and enable free-threading or JIT support through specific commands. The community anticipates that as these features mature, they will significantly impact Python's performance, particularly for CPU-bound tasks. Overall, Python 3.13 represents a pivotal moment in the language's evolution, addressing long-standing limitations and paving the way for improved performance in a multi-core world. As developers begin to explore these new capabilities, the future of Python looks promising, with the potential for substantial advancements in efficiency and speed.